Uitgebreide gids voor het samenvoegen van DataFrames in Python Pandas. Behandelt inner, outer, left, right joins met praktische voorbeelden voor data-analyse.
Python Pandas Samenvoegen: DataFrame Samenvoegstrategieën Beheersen voor Gegevensanalyse
Gegevensmanipulatie is een cruciaal aspect van data-analyse, en de Pandas-bibliotheek in Python biedt krachtige tools voor dit doel. Onder deze tools zijn het samenvoegen en koppelen van DataFrames essentiële bewerkingen voor het combineren van datasets op basis van gemeenschappelijke kolommen of indexen. Deze uitgebreide gids verkent verschillende DataFrame-koppelingsstrategieën in Pandas, waardoor u de kennis krijgt om gegevens uit verschillende bronnen effectief te combineren en te analyseren.
DataFrame Samenvoegen en Koppelen Begrijpen
Het samenvoegen en koppelen van DataFrames omvat het combineren van twee of meer DataFrames tot één enkel DataFrame op basis van een gedeelde kolom of index. Het primaire verschil tussen `merge` en `join` is dat `merge` een functie is van de Pandas-bibliotheek en doorgaans DataFrames koppelt op kolommen, terwijl `join` een DataFrame-methode is die DataFrames voornamelijk op indexen koppelt, hoewel het ook met kolommen kan worden gebruikt.
Kernconcepten
- DataFrames: Tweedimensionale gelabelde datastructuren met kolommen van potentieel verschillende typen.
- Gemeenschappelijke Kolommen/Indexen: Kolommen of indexen die dezelfde naam en datatype delen over DataFrames, dienend als basis voor samenvoegen/koppelen.
- Koppelingstypen: Verschillende strategieën voor het omgaan met niet-overeenkomende rijen tijdens het samenvoeg-/koppelingsproces, waaronder inner, outer, left en right joins.
DataFrame Samenvoegen met `pd.merge()`
De functie `pd.merge()` is de primaire tool voor het samenvoegen van DataFrames op basis van kolommen. Het biedt een flexibele manier om gegevens te combineren op basis van één of meer gemeenschappelijke kolommen.
Syntaxis
pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=True, indicator=False, validate=None)
Parameters
- left: Het linker DataFrame om samen te voegen.
- right: Het rechter DataFrame om samen te voegen.
- how: Het type samenvoeging dat moet worden uitgevoerd ('inner', 'outer', 'left', 'right'). Standaard is 'inner'.
- on: De naam van de kolom(men) om op te koppelen. Deze moeten in beide DataFrames te vinden zijn.
- left_on: De naam van de kolom(men) in het linker DataFrame om te gebruiken als koppelingssleutels.
- right_on: De naam van de kolom(men) in het rechter DataFrame om te gebruiken als koppelingssleutels.
- left_index: Indien True, gebruik de index van het linker DataFrame als koppelingssleutel(s).
- right_index: Indien True, gebruik de index van het rechter DataFrame als koppelingssleutel(s).
- sort: Sorteer het resultaat DataFrame lexicografisch op de koppelingssleutels. Standaard is False.
- suffixes: Een tuple van string-achtervoegsels die moeten worden toegepast op overlappende kolomnamen. Standaard is ('_x', '_y').
- copy: Indien False, vermijd het kopiëren van gegevens naar het nieuwe DataFrame waar mogelijk. Standaard is True.
- indicator: Indien True, voegt een kolom genaamd '_merge' toe die de bron van elke rij aangeeft.
- validate: Controleert of de samenvoeging van het opgegeven type is. "one_to_one", "one_to_many", "many_to_one", "many_to_many".
Koppelingstypen Uitgelegd
De parameter `how` in `pd.merge()` bepaalt het type uitgevoerde koppeling. De verschillende koppelingstypen behandelen niet-overeenkomende rijen op verschillende manieren.
Inner Join
Een inner join retourneert alleen de rijen die overeenkomende waarden hebben in beide DataFrames op basis van de koppelingssleutels. Rijen met niet-overeenkomende waarden worden uit het resultaat uitgesloten.
Voorbeeld:
Overweeg twee DataFrames:
import pandas as pd
# DataFrame 1: Customer Orders
df_orders = pd.DataFrame({
'order_id': [1, 2, 3, 4, 5],
'customer_id': [101, 102, 103, 104, 105],
'product_id': [1, 2, 1, 3, 2],
'quantity': [2, 1, 3, 1, 2]
})
# DataFrame 2: Customer Information
df_customers = pd.DataFrame({
'customer_id': [101, 102, 103, 106],
'customer_name': ['Alice', 'Bob', 'Charlie', 'David'],
'country': ['USA', 'Canada', 'UK', 'Australia']
})
# Inner Join
df_inner = pd.merge(df_orders, df_customers, on='customer_id', how='inner')
print(df_inner)
Output:
order_id customer_id product_id quantity customer_name country
0 1 101 1 2 Alice USA
1 2 102 2 1 Bob Canada
2 3 103 1 3 Charlie UK
In dit voorbeeld combineert de inner join de `df_orders` en `df_customers` DataFrames op basis van de kolom `customer_id`. Alleen klanten die bestellingen hebben geplaatst, zijn opgenomen in het resultaat. Klant 'David' (customer_id 106) is uitgesloten omdat hij geen bestellingen heeft.
Outer Join (Volledige Outer Join)
Een outer join retourneert alle rijen van beide DataFrames, inclusief niet-overeenkomende rijen. Als een rij geen match heeft in het andere DataFrame, zullen de corresponderende kolommen `NaN` (Not a Number) waarden bevatten.
Voorbeeld:
# Outer Join
df_outer = pd.merge(df_orders, df_customers, on='customer_id', how='outer')
print(df_outer)
Output:
order_id customer_id product_id quantity customer_name country
0 1.0 101 1.0 2.0 Alice USA
1 2.0 102 2.0 1.0 Bob Canada
2 3.0 103 1.0 3.0 Charlie UK
3 4.0 104 3.0 1.0 NaN NaN
4 5.0 105 2.0 2.0 NaN NaN
5 NaN 106 NaN NaN David Australia
De outer join omvat alle klanten en alle bestellingen. Klanten 104 en 105 hebben bestellingen maar geen klantinformatie, en klant 106 heeft klantinformatie maar geen bestellingen. De ontbrekende waarden worden weergegeven als `NaN`.
Left Join
Een left join retourneert alle rijen van het linker DataFrame en de overeenkomende rijen van het rechter DataFrame. Als een rij in het linker DataFrame geen match heeft in het rechter DataFrame, zullen de corresponderende kolommen van het rechter DataFrame `NaN` waarden bevatten.
Voorbeeld:
# Left Join
df_left = pd.merge(df_orders, df_customers, on='customer_id', how='left')
print(df_left)
Output:
order_id customer_id product_id quantity customer_name country
0 1 101 1 2 Alice USA
1 2 102 2 1 Bob Canada
2 3 103 1 3 Charlie UK
3 4 104 3 1 NaN NaN
4 5 105 2 2 NaN NaN
De left join omvat alle bestellingen van `df_orders`. Klanten 104 en 105 hebben bestellingen maar geen klantinformatie, dus de kolommen `customer_name` en `country` zijn `NaN` voor die bestellingen.
Right Join
Een right join retourneert alle rijen van het rechter DataFrame en de overeenkomende rijen van het linker DataFrame. Als een rij in het rechter DataFrame geen match heeft in het linker DataFrame, zullen de corresponderende kolommen van het linker DataFrame `NaN` waarden bevatten.
Voorbeeld:
# Right Join
df_right = pd.merge(df_orders, df_customers, on='customer_id', how='right')
print(df_right)
Output:
order_id customer_id product_id quantity customer_name country
0 1.0 101 1.0 2.0 Alice USA
1 2.0 102 2.0 1.0 Bob Canada
2 3.0 103 1.0 3.0 Charlie UK
3 NaN 106 NaN NaN David Australia
De right join omvat alle klanten van `df_customers`. Klant 106 heeft klantinformatie maar geen bestellingen, dus de kolommen `order_id`, `product_id` en `quantity` zijn `NaN` voor die klant.
DataFrame Koppelen met `df.join()`
De `df.join()`-methode wordt voornamelijk gebruikt om DataFrames te koppelen op basis van hun indexen. Het kan ook worden gebruikt om op kolommen te koppelen, maar het is doorgaans handiger om `pd.merge()` te gebruiken voor kolomgebaseerde koppelingen.
Syntaxis
DataFrame.join(other, on=None, how='left', lsuffix='', rsuffix='', sort=False)
Parameters
- other: Het andere DataFrame om te koppelen.
- on: Kolomnaam om op te koppelen. Moet worden doorgegeven als de index niet wordt gebruikt als koppelingssleutel.
- how: Hoe de bewerking van de linker- en rechtersets moet worden afgehandeld. Standaard is 'left'.
- lsuffix: Achtervoegsel dat moet worden gebruikt vanuit het linker DataFrame om overlappende kolomnamen te overschrijven.
- rsuffix: Achtervoegsel dat moet worden gebruikt vanuit het rechter DataFrame om overlappende kolomnamen te overschrijven.
- sort: Sorteer het resultaat DataFrame lexicografisch op de koppelingssleutels. Standaard is False.
Koppelen op Index
Wanneer u op de index koppelt, wordt de parameter `on` niet gebruikt.
Voorbeeld:
# DataFrame 1: Customer Orders met Customer ID als Index
df_orders_index = df_orders.set_index('customer_id')
# DataFrame 2: Customer Information met Customer ID als Index
df_customers_index = df_customers.set_index('customer_id')
# Koppelen op Index (Left Join)
df_join_index = df_orders_index.join(df_customers_index, how='left')
print(df_join_index)
Output:
order_id product_id quantity customer_name country
customer_id
101 1 1 2 Alice USA
102 2 2 1 Bob Canada
103 3 1 3 Charlie UK
104 4 3 1 NaN NaN
105 5 2 2 NaN NaN
In dit voorbeeld wordt de methode `join()` gebruikt om een left join uit te voeren op de index (`customer_id`). Het resultaat is vergelijkbaar met de left join met `pd.merge()`, maar de koppeling is gebaseerd op de index in plaats van een kolom.
Koppelen op Kolom
Om op een kolom te koppelen met `df.join()`, moet u de parameter `on` opgeven.
Voorbeeld:
# Koppelen op een kolom
df_join_column = df_orders.join(df_customers.set_index('customer_id'), on='customer_id', how='left')
print(df_join_column)
Output:
order_id customer_id product_id quantity customer_name country
0 1 101 1 2 Alice USA
1 2 102 2 1 Bob Canada
2 3 103 1 3 Charlie UK
3 4 104 3 1 NaN NaN
4 5 105 2 2 NaN NaN
Dit voorbeeld demonstreert het koppelen van `df_orders` met `df_customers` met behulp van de kolom `customer_id`. Merk op dat de `customer_id` is ingesteld als de index in `df_customers` voordat de koppeling wordt uitgevoerd.
Omgaan met Overlappende Kolommen
Bij het samenvoegen of koppelen van DataFrames is het gebruikelijk om overlappende kolomnamen tegen te komen (kolommen met dezelfde naam in beide DataFrames). Pandas biedt de parameter `suffixes` in `pd.merge()` en de parameters `lsuffix` en `rsuffix` in `df.join()` om deze situaties af te handelen.
Gebruik van `suffixes` in `pd.merge()`
De parameter `suffixes` stelt u in staat om achtervoegsels op te geven die worden toegevoegd aan de overlappende kolomnamen om ze te onderscheiden.
Voorbeeld:
# DataFrame 1: Product Informatie
df_products1 = pd.DataFrame({
'product_id': [1, 2, 3],
'product_name': ['Product A', 'Product B', 'Product C'],
'price': [10, 20, 15]
})
# DataFrame 2: Product Informatie (met potentieel bijgewerkte prijzen)
df_products2 = pd.DataFrame({
'product_id': [1, 2, 4],
'product_name': ['Product A', 'Product B', 'Product D'],
'price': [12, 18, 25]
})
# Samenvoegen met achtervoegsels
df_merged_suffixes = pd.merge(df_products1, df_products2, on='product_id', suffixes=('_old', '_new'))
print(df_merged_suffixes)
Output:
product_id product_name_old price_old product_name_new price_new
0 1 Product A 10 Product A 12
1 2 Product B 20 Product B 18
In dit voorbeeld zijn de kolommen `product_name` en `price` aanwezig in beide DataFrames. De parameter `suffixes` voegt de achtervoegsels `_old` en `_new` toe om de kolommen van respectievelijk het linker en rechter DataFrame te onderscheiden.
Gebruik van `lsuffix` en `rsuffix` in `df.join()`
De parameters `lsuffix` en `rsuffix` bieden vergelijkbare functionaliteit voor `df.join()`. `lsuffix` voegt toe aan de overlappende kolommen van het linker DataFrame, en `rsuffix` aan die van het rechter DataFrame.
Voorbeeld:
# Koppelen met lsuffix en rsuffix
df_products1_index = df_products1.set_index('product_id')
df_products2_index = df_products2.set_index('product_id')
df_joined_suffixes = df_products1_index.join(df_products2_index, lsuffix='_old', rsuffix='_new', how='outer')
print(df_joined_suffixes)
Output:
product_name_old price_old product_name_new price_new
product_id
1 Product A 10.0 Product A 12.0
2 Product B 20.0 Product B 18.0
3 Product C 15.0 NaN NaN
4 NaN NaN Product D 25.0
Praktische Voorbeelden en Gebruiksscenario's
Het samenvoegen en koppelen van DataFrames wordt veel gebruikt in verschillende data-analyse scenario's. Hier zijn enkele praktische voorbeelden:
Verkoopgegevens Combineren met Productinformatie
Een veelvoorkomend gebruiksscenario is het combineren van verkoopgegevens met productinformatie. Stel dat u een DataFrame hebt met verkooptransacties en een ander DataFrame met productdetails. U kunt deze DataFrames samenvoegen om de verkoopgegevens te verrijken met productinformatie.
Voorbeeld:
# Verkooptransactiegegevens
df_sales = pd.DataFrame({
'transaction_id': [1, 2, 3, 4, 5],
'product_id': [101, 102, 103, 101, 104],
'quantity': [2, 1, 3, 1, 2],
'sales_date': ['2023-01-15', '2023-02-20', '2023-03-10', '2023-04-05', '2023-05-01']
})
# Productinformatiegegevens
df_products = pd.DataFrame({
'product_id': [101, 102, 103, 104],
'product_name': ['Laptop', 'Mouse', 'Keyboard', 'Monitor'],
'category': ['Electronics', 'Electronics', 'Electronics', 'Electronics'],
'price': [1200, 25, 75, 300]
})
# Verkoopgegevens samenvoegen met productinformatie
df_sales_enriched = pd.merge(df_sales, df_products, on='product_id', how='left')
print(df_sales_enriched)
Output:
transaction_id product_id quantity sales_date product_name category price
0 1 101 2 2023-01-15 Laptop Electronics 1200
1 2 102 1 2023-02-20 Mouse Electronics 25
2 3 103 3 2023-03-10 Keyboard Electronics 75
3 4 101 1 2023-04-05 Laptop Electronics 1200
4 5 104 2 2023-05-01 Monitor Electronics 300
Het resulterende DataFrame `df_sales_enriched` bevat de verkooptransacties samen met de corresponderende productinformatie, wat een gedetailleerdere analyse van verkooptrends en productprestaties mogelijk maakt.
Klantgegevens Combineren met Demografische Informatie
Een ander veelvoorkomend gebruiksscenario is het combineren van klantgegevens met demografische informatie. Dit maakt het mogelijk om klantgedrag te analyseren op basis van demografische factoren.
Voorbeeld:
# Klantgegevens
df_customers = pd.DataFrame({
'customer_id': [1, 2, 3, 4, 5],
'customer_name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
'city': ['New York', 'London', 'Tokyo', 'Sydney', 'Berlin']
})
# Demografische Informatiegegevens
df_demographics = pd.DataFrame({
'city': ['New York', 'London', 'Tokyo', 'Sydney', 'Berlin'],
'population': [8419000, 8982000, 13960000, 5312000, 3769000],
'average_income': [75000, 65000, 85000, 90000, 55000]
})
# Klantgegevens samenvoegen met demografische informatie
df_customer_demographics = pd.merge(df_customers, df_demographics, on='city', how='left')
print(df_customer_demographics)
Output:
customer_id customer_name city population average_income
0 1 Alice New York 8419000 75000
1 2 Bob London 8982000 65000
2 3 Charlie Tokyo 13960000 85000
3 4 David Sydney 5312000 90000
4 5 Eve Berlin 3769000 55000
Het resulterende DataFrame `df_customer_demographics` bevat klantgegevens samen met de demografische informatie voor hun respectievelijke steden, wat analyse van klantgedrag op basis van stadsdemografie mogelijk maakt.
Wereldwijde Supply Chain Gegevens Analyseren
Pandas samenvoegen is waardevol voor het analyseren van wereldwijde supply chain gegevens, waarbij informatie vaak verspreid is over meerdere tabellen. Het koppelen van bijvoorbeeld leveranciersgegevens, verzendinformatie en verkoopcijfers kan knelpunten aan het licht brengen en logistiek optimaliseren.
Voorbeeld:
# Leveranciersgegevens
df_suppliers = pd.DataFrame({
'supplier_id': [1, 2, 3],
'supplier_name': ['GlobalTech', 'EuroParts', 'AsiaSource'],
'location': ['Taiwan', 'Germany', 'China']
})
# Verzendgegevens
df_shipments = pd.DataFrame({
'shipment_id': [101, 102, 103, 104],
'supplier_id': [1, 2, 3, 1],
'destination': ['USA', 'Canada', 'Australia', 'Japan'],
'shipment_date': ['2023-01-10', '2023-02-15', '2023-03-20', '2023-04-25']
})
# Leveranciers- en verzendgegevens samenvoegen
df_supply_chain = pd.merge(df_shipments, df_suppliers, on='supplier_id', how='left')
print(df_supply_chain)
Output:
shipment_id supplier_id destination shipment_date supplier_name location
0 101 1 USA 2023-01-10 GlobalTech Taiwan
1 102 2 Canada 2023-02-15 EuroParts Germany
2 103 3 Australia 2023-03-20 AsiaSource China
3 104 1 Japan 2023-04-25 GlobalTech Taiwan
Geavanceerde Samenvoegtechnieken
Samenvoegen op Meerdere Kolommen
U kunt DataFrames samenvoegen op basis van meerdere kolommen door een lijst met kolomnamen door te geven aan de parameter `on`.
Voorbeeld:
# DataFrame 1
df1 = pd.DataFrame({
'product_id': [1, 1, 2, 2],
'color': ['red', 'blue', 'red', 'blue'],
'quantity': [10, 15, 20, 25]
})
# DataFrame 2
df2 = pd.DataFrame({
'product_id': [1, 1, 2, 2],
'color': ['red', 'blue', 'red', 'blue'],
'price': [5, 7, 8, 10]
})
# Samenvoegen op meerdere kolommen
df_merged_multiple = pd.merge(df1, df2, on=['product_id', 'color'], how='inner')
print(df_merged_multiple)
Output:
product_id color quantity price
0 1 red 10 5
1 1 blue 15 7
2 2 red 20 8
3 2 blue 25 10
Samenvoegen met Verschillende Kolomnamen
Als de koppelingskolommen verschillende namen hebben in de twee DataFrames, kunt u de parameters `left_on` en `right_on` gebruiken om de kolomnamen op te geven die moeten worden gebruikt voor het samenvoegen.
Voorbeeld:
# DataFrame 1
df1 = pd.DataFrame({
'product_id': [1, 2, 3],
'product_name': ['Product A', 'Product B', 'Product C']
})
# DataFrame 2
df2 = pd.DataFrame({
'id': [1, 2, 4],
'price': [10, 20, 25]
})
# Samenvoegen met verschillende kolomnamen
df_merged_different = pd.merge(df1, df2, left_on='product_id', right_on='id', how='left')
print(df_merged_different)
Output:
product_id product_name id price
0 1 Product A 1.0 10.0
1 2 Product B 2.0 20.0
2 3 Product C NaN NaN
Gebruik van `indicator` voor Samenvoeganalyse
De parameter `indicator` in `pd.merge()` voegt een kolom genaamd `_merge` toe aan het resulterende DataFrame, die de bron van elke rij aangeeft. Dit is handig voor het begrijpen welke rijen zijn gematcht en welke niet.
Voorbeeld:
# Samenvoegen met indicator
df_merged_indicator = pd.merge(df_orders, df_customers, on='customer_id', how='outer', indicator=True)
print(df_merged_indicator)
Output:
order_id customer_id product_id quantity customer_name country _merge
0 1.0 101 1.0 2.0 Alice USA both
1 2.0 102 2.0 1.0 Bob Canada both
2 3.0 103 1.0 3.0 Charlie UK both
3 4.0 104 3.0 1.0 NaN NaN left_only
4 5.0 105 2.0 2.0 NaN NaN left_only
5 NaN 106 NaN NaN David Australia right_only
De kolom `_merge` geeft aan of de rij afkomstig is van beide DataFrames (`both`), alleen het linker DataFrame (`left_only`), of alleen het rechter DataFrame (`right_only`).
Validatie van Samenvoegtypen
De parameter `validate` zorgt ervoor dat de samenvoegbewerking overeenkomt met verwachte relatietypen tussen de DataFrames (bijv. 'one_to_one', 'one_to_many'). Dit helpt inconsistenties en fouten in gegevens te voorkomen.
Voorbeeld:
# Voorbeeld met één-op-één validatie
df_users = pd.DataFrame({
'user_id': [1, 2, 3],
'username': ['john_doe', 'jane_smith', 'peter_jones']
})
df_profiles = pd.DataFrame({
'user_id': [1, 2, 3],
'profile_description': ['Software Engineer', 'Data Scientist', 'Project Manager']
})
# Een één-op-één samenvoeging uitvoeren met validatie
merged_df = pd.merge(df_users, df_profiles, on='user_id', validate='one_to_one')
print(merged_df)
Als de samenvoeging de opgegeven validatie schendt (bijv. een many-to-one relatie wanneer 'one_to_one' is opgegeven), zal een `MergeError` worden gegenereerd, wat u waarschuwt voor mogelijke problemen met gegevensintegriteit.
Prestatieoverwegingen
Het samenvoegen en koppelen van DataFrames kan rekenkundig duur zijn, vooral voor grote datasets. Hier zijn enkele tips om de prestaties te verbeteren:
- Gebruik het juiste koppelingstype: Het kiezen van het juiste koppelingstype kan de prestaties aanzienlijk beïnvloeden. Als u bijvoorbeeld alleen overeenkomende rijen nodig hebt, gebruik dan een inner join.
- Indexeer de koppelingskolommen: Het indexeren van de koppelingskolommen kan het samenvoegproces versnellen.
- Gebruik geschikte gegevenstypen: Zorg ervoor dat de koppelingskolommen compatibele gegevenstypen hebben.
- Vermijd onnodige kopieën: Stel `copy=False` in `pd.merge()` en `df.join()` in om het maken van onnodige kopieën van de gegevens te voorkomen.
Conclusie
Het samenvoegen en koppelen van DataFrames zijn fundamentele bewerkingen in data-analyse. Door de verschillende koppelingstypen en technieken te begrijpen, kunt u gegevens uit verschillende bronnen effectief combineren en analyseren, waardoor waardevolle inzichten worden ontsloten en weloverwogen besluitvorming wordt gestimuleerd. Van het combineren van verkoopgegevens met productinformatie tot het analyseren van wereldwijde toeleveringsketens, het beheersen van deze technieken stelt u in staat complexe gegevensmanipulatietaken met vertrouwen aan te pakken. Vergeet niet de prestatie-implicaties in overweging te nemen bij het werken met grote datasets en maak gebruik van geavanceerde functies zoals de parameters `indicator` en `validate` voor een robuustere en inzichtelijkere analyse.